
#include <iostream>
using namespace std;
//协变

//class A{};
//
//class B:public A{};
//
//class Person {
//public:
//    virtual A* BuyTicket()     //虚函数
//    {
//        cout << "Person---买票----全票" << endl;
//        return nullptr;
//    }
//};
//class Student :public Person
//{
//    //函数同名----隐藏关系 /重定义
//public:
//
//    //虚函数的重写/覆盖
//    //三同：函数名相同 参数相同 返回值也要一样
//    virtual A* BuyTicket()
//    {
//        cout << "Student---买票----半票" << endl;
//        return nullptr;
//    }
//};
////class Soldier :public Person {
////public:
////    virtual void BuyTicket()
////    {
////        cout << "Soldier---买票----优先买票" << endl;
////    }
////};
//void func(Person& p)
//{
//    p.BuyTicket();
//}
//
//int main()
//{
//    Person p;
//    Student st;
//    //Soldier sd;
//
//    func(p);
//    func(st);
//   // func(sd);
//
//    //多态调用:（指针或者引用）指向的对象有关系
//    //普通对象调用：跟调用的对象有关
//
//    return 0;
//}





//class Person {
//public:
//	 ~Person()
//	{
//		cout << "~Person的析构函数" << _p << endl;
//		delete[] _p;
//	}
//protected:
//	int* _p = new int[10];
//};
//
//class Student :public Person {
//public:
//	~Student()
//	{
//		cout << "~Student的析构函数" << _s << endl;
//		delete[] _s;
//	}
//protected:
//	int* _s = new int[10];
//};
//int main()
//{
//	//Person p;
//	//Student s;
//
//	Person* ptr1 = new Person;
//	Person* ptr2 = new Student;  //前面这个Person 是类型  后面是对象
//
//	delete ptr1;
//	delete ptr2;
//	// delete行为 1、使用指针调用函数 2、operator delete(ptr);  去析构 free
//	//使用指针调用析构函数这块儿，跟指针类型无关系，他只跟你指向对象的有关系
//	//多态调用---调用对应的析构函数----跟引用或者指针所指的对象有关
//	//析构函数是不是全部要重新命名destrutor()
//	// ptr->destrutor() //继承谈到过
//
//	return 0;
//}



//如何实现不能被继承的类
//1、把构造函数放到private 里面是无法被继承的
//2、final:禁止该类被继承   --最终类
class Car {
public:
	virtual void Drive() 
	{

	}
};


class BMW :public Car {
public:
	virtual void Drive() override        //override 对子类而言的  final 适度父类而言
	{
		cout << "驾驶乐趣" << endl;
	}
};

int main()
{
	//BMW b;
	//BMW* b = new BMW;

	return 0;
}








// #include <iostream>
// using namespace std;
// ////抽象类
// ////1、没有对应的实体的时候，
// ////2、强制子类完成对父类重写的时候
// ////override  --检查子类有没有对父类虚函数完成重写的 
// ////抽象类---并没有强制让你完成对纯虚函数的重写，
// //class car {
// //public:
// //    virtual void Drive() = 0;  //纯虚函数
// //};
// //class BMW :public car {
// ////
// //public:
// //    virtual void Drive()  //virtual 不一定写，不写的话同样完成了纯虚函数的重写   ---函数名相同，返回值相同   参数相同
// //    {
// //        cout << "BMW" << endl;
// //    }
// //};
// //int main()
// //{
// //	//car c;  //不能实例化对象的
// //	BMW bmw;
// //
// //
// //
// //	return 0;
// //}


// //class A {
// //public:
// //	virtual void func(int val=1)
// //	{
// //	std::cout << "A->" << val << std::endl;
// //	}
// //	virtual void test() { func(); }   //this->func();   A* ->func()  //满足多态条件是一个多态调用叭
// //};
// //class B : public A
// //{
// //public:
// //	void func(int val = 0)    //void func(int val = 1)
// //	{ 
// //		std::cout << "B->" << val << std::endl;     //B->1
// //	}
// //};
// //int main(int argc, char* argv[])
// //	{
// //	B* p = new B;
// //	p->test();   //A类的函数
// //	p->func();    //不是多态的调用
// //	return 0;
// //}


// class Base {
// public:
// 	virtual void Func1()
// 	{
// 		cout << "Func1()" << endl;
// 	}

// 	virtual void Func2()
// 	{
// 		cout << "Func2()" << endl;
// 	}
// 	virtual void Func3()
// 	{
// 		cout << "Func3()" << endl;
// 	}
// 	 void Func4()
// 	{
// 		cout << "Func4()" << endl;
// 	}
// protected:
// 	int _a;     //4
// 	char _ch;   //1     内存对齐之后----》12
// };

// int main()
// {
// 	cout << sizeof Base << endl;
// 	Base b;
// 	return 0;
// }

